home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / hummer.swf / scripts / %3Cdefault package%3E / soundClass.as < prev   
Encoding:
Text File  |  2007-01-08  |  26.4 KB  |  661 lines

  1. var ┬º\x01┬º = 846;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 846)
  6.    {
  7.       set("\x01",eval("\x01") - 642);
  8.       ┬º┬ºpush(true);
  9.    }
  10.    else
  11.    {
  12.       if(eval("\x01") == 646)
  13.       {
  14.          set("\x01",eval("\x01") - 352);
  15.          nextFrame();
  16.          toggleHighQuality();
  17.          play();
  18.          while(true)
  19.          {
  20.             ┬º┬ºpop()[┬º┬ºpop()][eval(┬º┬ºconstant(16))] = 0;
  21.             set(┬º┬ºconstant(16),eval(┬º┬ºconstant(16)) + 1);
  22.             if(eval(┬º┬ºconstant(16)) >= _loc1_[┬º┬ºconstant(6)][┬º┬ºconstant(19)])
  23.             {
  24.                break;
  25.             }
  26.             ┬º┬ºpush(_loc1_);
  27.             ┬º┬ºpush(┬º┬ºconstant(6));
  28.          }
  29.          ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  30.          eval(┬º┬ºconstant(7))[┬º┬ºconstant(8)][┬º┬ºconstant(20)] = function(b)
  31.          {
  32.             var _loc2_ = this[┬º┬ºconstant(0)] >>> 3 & 63;
  33.             if(4294967288 <= this[┬º┬ºconstant(0)])
  34.             {
  35.                this[┬º┬ºconstant(1)] = this[┬º┬ºconstant(1)] + 1;
  36.                this[┬º┬ºconstant(0)] -= 4294967296;
  37.             }
  38.             this[┬º┬ºconstant(0)] += 8;
  39.             this[┬º┬ºconstant(4)][_loc2_] = b & 255;
  40.             trace(_loc2_);
  41.             if(_loc2_ >= 63)
  42.             {
  43.                this[┬º┬ºconstant(15)](this[┬º┬ºconstant(4)],0);
  44.             }
  45.          };
  46.          eval(┬º┬ºconstant(7))[┬º┬ºconstant(8)][┬º┬ºconstant(21)] = function()
  47.          {
  48.             var _loc4_ = new ┬º\┬º\┬ºconstant(3)┬º(8);
  49.             var _loc2_ = undefined;
  50.             var _loc3_ = undefined;
  51.             _loc2_ = 0;
  52.             while(_loc2_ < 4)
  53.             {
  54.                _loc4_[_loc2_] = this[┬º┬ºconstant(0)] >>> _loc2_ * 8 & 255;
  55.                _loc4_[_loc2_ + 4] = this[┬º┬ºconstant(1)] >>> _loc2_ * 8 & 255;
  56.                _loc2_ = _loc2_ + 1;
  57.             }
  58.             var _loc6_ = this[┬º┬ºconstant(0)] >>> 3 & 63;
  59.             var _loc5_ = _loc6_ >= 56 ? 120 - _loc6_ : 56 - _loc6_;
  60.             this[┬º┬ºconstant(20)](128);
  61.             _loc2_ = 1;
  62.             while(_loc2_ < _loc5_)
  63.             {
  64.                this[┬º┬ºconstant(20)](0);
  65.                _loc2_ = _loc2_ + 1;
  66.             }
  67.             _loc2_ = 0;
  68.             while(_loc2_ < 8)
  69.             {
  70.                this[┬º┬ºconstant(20)](_loc4_[_loc2_]);
  71.                _loc2_ = _loc2_ + 1;
  72.             }
  73.             _loc2_ = 0;
  74.             while(_loc2_ < 4)
  75.             {
  76.                _loc3_ = 0;
  77.                while(_loc3_ < 4)
  78.                {
  79.                   this[┬º┬ºconstant(6)][_loc2_ * 4 + _loc3_] = this[┬º┬ºconstant(2)][_loc2_] >>> _loc3_ * 8 & 255;
  80.                   _loc3_ = _loc3_ + 1;
  81.                }
  82.                _loc2_ = _loc2_ + 1;
  83.             }
  84.          };
  85.          eval(┬º┬ºconstant(7))[┬º┬ºconstant(8)][┬º┬ºconstant(22)] = function(bt)
  86.          {
  87.             var _loc1_ = ┬º┬ºconstant(23);
  88.             var _loc2_ = _loc1_[┬º┬ºconstant(24)](bt >> 4) + _loc1_[┬º┬ºconstant(24)](bt & 15);
  89.             return _loc2_;
  90.          };
  91.          eval(┬º┬ºconstant(7))[┬º┬ºconstant(8)][┬º┬ºconstant(25)] = function(m)
  92.          {
  93.             var _loc4_ = ┬º┬ºconstant(26);
  94.             this[┬º┬ºconstant(18)]();
  95.             var _loc2_ = 0;
  96.             while(_loc2_ < m[┬º┬ºconstant(19)])
  97.             {
  98.                this[┬º┬ºconstant(20)](m[┬º┬ºconstant(27)](_loc2_));
  99.                _loc2_ = _loc2_ + 1;
  100.             }
  101.             this[┬º┬ºconstant(21)]();
  102.             _loc2_ = 0;
  103.             while(_loc2_ < 16)
  104.             {
  105.                _loc4_ += this[┬º┬ºconstant(22)](this[┬º┬ºconstant(6)][_loc2_]);
  106.                _loc2_ = _loc2_ + 1;
  107.             }
  108.             return _loc4_;
  109.          };
  110.          eval(┬º┬ºconstant(7))[┬º┬ºconstant(8)][┬º┬ºconstant(28)] = function(d, m)
  111.          {
  112.             return this[┬º┬ºconstant(25)](m) == d;
  113.          };
  114.          eval(┬º┬ºconstant(7))[┬º┬ºconstant(8)][┬º┬ºconstant(29)] = function(input)
  115.          {
  116.             return this[┬º┬ºconstant(25)](input);
  117.          };
  118.          eval(┬º┬ºconstant(31))[┬º┬ºconstant(32)](┬º┬ºconstant(30),eval(┬º┬ºconstant(7)));
  119.          break;
  120.       }
  121.       if(eval("\x01") == 8)
  122.       {
  123.          set("\x01",eval("\x01") + 638);
  124.          if(┬º┬ºpop())
  125.          {
  126.             set("\x01",eval("\x01") - 352);
  127.          }
  128.       }
  129.       else if(eval("\x01") == 204)
  130.       {
  131.          set("\x01",eval("\x01") + 614);
  132.          if(┬º┬ºpop())
  133.          {
  134.             set("\x01",eval("\x01") + 80);
  135.          }
  136.       }
  137.       else
  138.       {
  139.          if(eval("\x01") == 818)
  140.          {
  141.             set("\x01",eval("\x01") + 80);
  142.             loop2:
  143.             while(true)
  144.             {
  145.                set(┬º┬ºpop(),┬º┬ºpop());
  146.                ┬º┬ºpush(true);
  147.                while(true)
  148.                {
  149.                   if(eval("\x01") == 573)
  150.                   {
  151.                      set("\x01",eval("\x01") - 415);
  152.                      ┬º┬ºpush(true);
  153.                      continue;
  154.                   }
  155.                   if(eval("\x01") == 988)
  156.                   {
  157.                      set("\x01",eval("\x01") - 239);
  158.                      ┬º┬ºpush(true);
  159.                      continue;
  160.                   }
  161.                   if(eval("\x01") == 19)
  162.                   {
  163.                      set("\x01",eval("\x01") + 827);
  164.                      if(┬º┬ºpop())
  165.                      {
  166.                         set("\x01",eval("\x01") - 30);
  167.                      }
  168.                      continue;
  169.                   }
  170.                   if(eval("\x01") == 281)
  171.                   {
  172.                      set("\x01",eval("\x01") + 15);
  173.                      break loop0;
  174.                   }
  175.                   if(eval("\x01") == 187)
  176.                   {
  177.                      set("\x01",eval("\x01") - 168);
  178.                      ┬º┬ºpush(true);
  179.                      continue;
  180.                   }
  181.                   if(eval("\x01") == 832)
  182.                   {
  183.                      set("\x01",eval("\x01") - 127);
  184.                      ┬º┬ºpush(true);
  185.                      continue;
  186.                   }
  187.                   if(eval("\x01") == 160)
  188.                   {
  189.                      set("\x01",eval("\x01") + 540);
  190.                      break loop0;
  191.                   }
  192.                   if(eval("\x01") == 265)
  193.                   {
  194.                      set("\x01",eval("\x01") + 74);
  195.                      break loop0;
  196.                   }
  197.                   if(eval("\x01") == 700)
  198.                   {
  199.                      set("\x01",eval("\x01") - 629);
  200.                      ┬º┬ºpush(true);
  201.                      continue;
  202.                   }
  203.                   if(eval("\x01") == 917)
  204.                   {
  205.                      break;
  206.                   }
  207.                   if(eval("\x01") == 71)
  208.                   {
  209.                      set("\x01",eval("\x01") + 210);
  210.                      if(┬º┬ºpop())
  211.                      {
  212.                         set("\x01",eval("\x01") + 15);
  213.                      }
  214.                      continue;
  215.                   }
  216.                   if(eval("\x01") == 726)
  217.                   {
  218.                      break loop2;
  219.                   }
  220.                   if(eval("\x01") == 705)
  221.                   {
  222.                      set("\x01",eval("\x01") - 545);
  223.                      if(┬º┬ºpop())
  224.                      {
  225.                         set("\x01",eval("\x01") + 540);
  226.                      }
  227.                      continue;
  228.                   }
  229.                   if(eval("\x01") == 237)
  230.                   {
  231.                      set("\x01",eval("\x01") + 4);
  232.                      break loop0;
  233.                   }
  234.                   if(eval("\x01") == 296)
  235.                   {
  236.                      set("\x01",eval("\x01") + 138);
  237.                      ┬º┬ºpush(true);
  238.                      continue;
  239.                   }
  240.                   if(eval("\x01") == 755)
  241.                   {
  242.                      set("\x01",eval("\x01") + 162);
  243.                      if(┬º┬ºpop())
  244.                      {
  245.                         set("\x01",eval("\x01") - 730);
  246.                      }
  247.                      continue;
  248.                   }
  249.                   if(eval("\x01") == 681)
  250.                   {
  251.                      set("\x01",eval("\x01") - 341);
  252.                      if(┬º┬ºpop())
  253.                      {
  254.                         set("\x01",eval("\x01") - 307);
  255.                      }
  256.                      continue;
  257.                   }
  258.                   if(eval("\x01") == 339)
  259.                   {
  260.                      set("\x01",eval("\x01") + 342);
  261.                      ┬º┬ºpush(true);
  262.                      continue;
  263.                   }
  264.                   if(eval("\x01") == 158)
  265.                   {
  266.                      set("\x01",eval("\x01") + 79);
  267.                      if(┬º┬ºpop())
  268.                      {
  269.                         set("\x01",eval("\x01") + 4);
  270.                      }
  271.                      continue;
  272.                   }
  273.                   if(eval("\x01") == 1)
  274.                   {
  275.                      set("\x01",eval("\x01") + 831);
  276.                      ┬º┬ºpush(delete ┬º┬ºpop());
  277.                      break loop0;
  278.                   }
  279.                   if(eval("\x01") == 434)
  280.                   {
  281.                      set("\x01",eval("\x01") + 440);
  282.                      if(┬º┬ºpop())
  283.                      {
  284.                         set("\x01",eval("\x01") - 597);
  285.                      }
  286.                      continue;
  287.                   }
  288.                   if(eval("\x01") != 846)
  289.                   {
  290.                      if(eval("\x01") == 816)
  291.                      {
  292.                         set("\x01",eval("\x01") - 142);
  293.                         ┬º┬ºpush(true);
  294.                         continue;
  295.                      }
  296.                      if(eval("\x01") == 674)
  297.                      {
  298.                         set("\x01",eval("\x01") - 409);
  299.                         if(┬º┬ºpop())
  300.                         {
  301.                            set("\x01",eval("\x01") + 74);
  302.                         }
  303.                         continue;
  304.                      }
  305.                      if(eval("\x01") == 874)
  306.                      {
  307.                         set("\x01",eval("\x01") - 597);
  308.                         return new ┬º┬ºpop()[┬º┬ºconstant(3)]();
  309.                      }
  310.                      if(eval("\x01") == 241)
  311.                      {
  312.                         set("\x01",eval("\x01") + 475);
  313.                         ┬º┬ºpush(true);
  314.                         continue;
  315.                      }
  316.                      if(eval("\x01") == 749)
  317.                      {
  318.                         set("\x01",eval("\x01") - 748);
  319.                         if(┬º┬ºpop())
  320.                         {
  321.                            set("\x01",eval("\x01") + 831);
  322.                         }
  323.                         continue;
  324.                      }
  325.                      if(eval("\x01") == 716)
  326.                      {
  327.                         set("\x01",eval("\x01") + 10);
  328.                         if(┬º┬ºpop())
  329.                         {
  330.                            set("\x01",eval("\x01") + 262);
  331.                         }
  332.                         continue;
  333.                      }
  334.                      if(eval("\x01") != 277)
  335.                      {
  336.                         if(eval("\x01") == 340)
  337.                         {
  338.                            set("\x01",eval("\x01") - 307);
  339.                            prevFrame();
  340.                            break loop0;
  341.                         }
  342.                         if(eval("\x01") == 33)
  343.                         {
  344.                            set("\x01",eval("\x01") + 46);
  345.                            if(!_global.math)
  346.                            {
  347.                               _global.math = new Object();
  348.                            }
  349.                            ┬º┬ºpop();
  350.                            if(!_global.math.Vector)
  351.                            {
  352.                               var _loc2_ = math.Vector = function(x, y)
  353.                               {
  354.                                  this.initialize(x,y);
  355.                               }.prototype;
  356.                               _loc2_.initialize = function(x, y)
  357.                               {
  358.                                  this.x = x;
  359.                                  this.y = y;
  360.                               };
  361.                               _loc2_.toString = function()
  362.                               {
  363.                                  var _loc3_ = Math.round(this.x * 1000) / 1000;
  364.                                  var _loc2_ = Math.round(this.y * 1000) / 1000;
  365.                                  return "[" + _loc3_ + ", " + _loc2_ + "]";
  366.                               };
  367.                               _loc2_.reset = function(x, y)
  368.                               {
  369.                                  this.initialize(x,y);
  370.                               };
  371.                               _loc2_.getClone = function()
  372.                               {
  373.                                  return new math.Vector(this.x,this.y);
  374.                               };
  375.                               _loc2_.equals = function(v)
  376.                               {
  377.                                  return this.x == v.x && this.y == v.y;
  378.                               };
  379.                               _loc2_.plus = function(v)
  380.                               {
  381.                                  this.x += v.x;
  382.                                  this.y += v.y;
  383.                               };
  384.                               _loc2_.plusNew = function(v)
  385.                               {
  386.                                  return new math.Vector(this.x + v.x,this.y + v.y);
  387.                               };
  388.                               _loc2_.minus = function(v)
  389.                               {
  390.                                  this.x -= v.x;
  391.                                  this.y -= v.y;
  392.                               };
  393.                               _loc2_.minusNew = function(v)
  394.                               {
  395.                                  return new math[┬º┬ºconstant(3)](this.x - v.x,this.y - v.y);
  396.                               };
  397.                               _loc2_.negate = function()
  398.                               {
  399.                                  this.x = - this.x;
  400.                                  this.y = - this.y;
  401.                               };
  402.                               _loc2_.negateNew = function()
  403.                               {
  404.                                  return new math.Vector(- this.x,- this.y);
  405.                               };
  406.                               _loc2_.scale = function(s)
  407.                               {
  408.                                  this.x *= s;
  409.                                  this.y *= s;
  410.                               };
  411.                               _loc2_.scaleNew = function(s)
  412.                               {
  413.                                  return new math.Vector(this.x * s,this.y * s);
  414.                               };
  415.                               _loc2_.getLength = function()
  416.                               {
  417.                                  return Math.sqrt(this.x * this.x + this.y * this.y);
  418.                               };
  419.                               _loc2_.setLength = function(len)
  420.                               {
  421.                                  var _loc2_ = this.getLength();
  422.                                  !_loc2_ ? (this.x = len) : this.scale(len / _loc2_);
  423.                               };
  424.                               _loc2_.getAngle = function()
  425.                               {
  426.                                  return math.Degree.atan2D(this.y,this.x);
  427.                               };
  428.                               _loc2_.setAngle = function(ang)
  429.                               {
  430.                                  var _loc2_ = this.getLength();
  431.                                  this.x = _loc2_ * math.Degree.cosD(ang);
  432.                                  this.y = _loc2_ * math.Degree.sinD(ang);
  433.                               };
  434.                               _loc2_.rotate = function(ang)
  435.                               {
  436.                                  var _loc3_ = math.Degree.cosD(ang);
  437.                                  var _loc2_ = math.Degree.sinD(ang);
  438.                                  var _loc5_ = this.x * _loc3_ - this.y * _loc2_;
  439.                                  var _loc4_ = this.x * _loc2_ + this.y * _loc3_;
  440.                                  this.x = _loc5_;
  441.                                  this.y = _loc4_;
  442.                               };
  443.                               _loc2_.rotateNew = function(ang)
  444.                               {
  445.                                  var _loc2_ = new math.Vector(this.x,this.y);
  446.                                  _loc2_.rotate(ang);
  447.                                  return _loc2_;
  448.                               };
  449.                               _loc2_.dot = function(v)
  450.                               {
  451.                                  return this.x * v.x + this.y * v.y;
  452.                               };
  453.                               _loc2_.getNormal = function()
  454.                               {
  455.                                  return new math.Vector(- this.y,this.x);
  456.                               };
  457.                               _loc2_.isPerpTo = function(v)
  458.                               {
  459.                                  return this.dot(v) == 0;
  460.                               };
  461.                               _loc2_.isNormalTo = function(v)
  462.                               {
  463.                                  return this.isPerpTo(v);
  464.                               };
  465.                               _loc2_.angleBetween = function(v)
  466.                               {
  467.                                  var _loc3_ = this.dot(v);
  468.                                  var _loc2_ = _loc3_ / (this.getLength() * v.getLength());
  469.                                  return math.Degree.acosD(_loc2_);
  470.                               };
  471.                               _loc2_.__get__x = function()
  472.                               {
  473.                                  return this.$x;
  474.                               };
  475.                               _loc2_.__set__x = function(x)
  476.                               {
  477.                                  this.$x = x;
  478.                                  return this.x;
  479.                               };
  480.                               _loc2_.__get__y = function()
  481.                               {
  482.                                  return this.$y;
  483.                               };
  484.                               _loc2_.__set__y = function(y)
  485.                               {
  486.                                  this.$y = y;
  487.                                  return this.y;
  488.                               };
  489.                               _loc2_.__get__length = function()
  490.                               {
  491.                                  return this.getLength();
  492.                               };
  493.                               _loc2_.__set__length = function(len)
  494.                               {
  495.                                  this.setLength(len);
  496.                                  return this.length;
  497.                               };
  498.                               _loc2_.__get__angle = function()
  499.                               {
  500.                                  return this.getAngle();
  501.                               };
  502.                               _loc2_.__set__angle = function(ang)
  503.                               {
  504.                                  this.setAngle(ang);
  505.                                  return this.angle;
  506.                               };
  507.                               ┬º┬ºpush(_loc2_.addProperty("angle",_loc2_.__get__angle,_loc2_.__set__angle));
  508.                               ┬º┬ºpush(_loc2_.addProperty("length",_loc2_.__get__length,_loc2_.__set__length));
  509.                               ┬º┬ºpush(_loc2_.addProperty("x",_loc2_.__get__x,_loc2_.__set__x));
  510.                               ┬º┬ºpush(_loc2_.addProperty("y",_loc2_.__get__y,_loc2_.__set__y));
  511.                               ┬º┬ºpush(ASSetPropFlags(math.Vector.prototype,null,1));
  512.                            }
  513.                            ┬º┬ºpop();
  514.                         }
  515.                         break loop0;
  516.                      }
  517.                      continue loop2;
  518.                   }
  519.                   set("\x01",eval("\x01") - 30);
  520.                   ┬º┬ºpush(┬º┬ºpop() ^ ┬º┬ºpop() lt ┬º┬ºpop());
  521.                   while(true)
  522.                   {
  523.                      if(eval("\x01") == 710)
  524.                      {
  525.                         set("\x01",eval("\x01") - 196);
  526.                         ┬º┬ºpush(true);
  527.                      }
  528.                      else
  529.                      {
  530.                         if(eval("\x01") != 514)
  531.                         {
  532.                            if(eval("\x01") == 904)
  533.                            {
  534.                               set("\x01",eval("\x01") - 313);
  535.                               setProperty(┬º┬ºpop(), _X, ┬º┬ºpop());
  536.                               ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  537.                               break loop0;
  538.                            }
  539.                            if(eval("\x01") == 591)
  540.                            {
  541.                               set("\x01",eval("\x01") - 66);
  542.                               this._parent.stop();
  543.                               bg._x = 0;
  544.                               bg._y = 0;
  545.                               this._x = 0;
  546.                               this._y = 0;
  547.                               bg._width = Stage.width;
  548.                               bg._height = Stage.height;
  549.                               bg.swapDepths(10);
  550.                               _quality = "BEST";
  551.                               intro._xscale = 100;
  552.                               intro._yscale = 100;
  553.                               intro.swapDepths(11);
  554.                               intro._x = Math.round((Stage.width - intro._width) / 2);
  555.                               intro._y = Math.round((Stage.height - intro._height) / 2);
  556.                               loaded = function()
  557.                               {
  558.                                  this._parent.gotoAndStop(2);
  559.                               };
  560.                               gotoGamezhero = function()
  561.                               {
  562.                                  getUrl("http://www.gamezhero.com/?utm_campaign=hrc&utm_source=hrc&utm_medium=context_menu", "_blank");
  563.                               };
  564.                               gamezheroMenu = new ContextMenu();
  565.                               gamezheroMenu.builtInItems.forward_back = false;
  566.                               gamezheroMenu.builtInItems.loop = false;
  567.                               gamezheroMenu.builtInItems.play = false;
  568.                               gamezheroMenu.builtInItems.print = false;
  569.                               gamezheroMenu.builtInItems.rewind = false;
  570.                               gamezheroMenu.builtInItems.zoom = false;
  571.                               gamezheroMenu.builtInItems.save = false;
  572.                               gamezheroMenu.customItems.push(new ContextMenuItem("More Free Games - gamezhero.com",gotoGamezhero));
  573.                               _root.menu = gamezheroMenu;
  574.                            }
  575.                            break loop0;
  576.                         }
  577.                         set("\x01",eval("\x01") + 390);
  578.                         if(┬º┬ºpop())
  579.                         {
  580.                            set("\x01",eval("\x01") - 313);
  581.                         }
  582.                      }
  583.                      while(true)
  584.                      {
  585.                         if(eval("\x01") == 255)
  586.                         {
  587.                            set("\x01",eval("\x01") + 175);
  588.                            ┬º┬ºpush(true);
  589.                         }
  590.                         else if(eval("\x01") == 430)
  591.                         {
  592.                            set("\x01",eval("\x01") - 96);
  593.                            if(┬º┬ºpop())
  594.                            {
  595.                               set("\x01",eval("\x01") - 260);
  596.                            }
  597.                         }
  598.                         else
  599.                         {
  600.                            if(eval("\x01") == 334)
  601.                            {
  602.                               set("\x01",eval("\x01") - 260);
  603.                               ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop() + 1);
  604.                               break loop0;
  605.                            }
  606.                            if(eval("\x01") == 74)
  607.                            {
  608.                               set("\x01",eval("\x01") + 375);
  609.                               ┬º┬ºpush(true);
  610.                            }
  611.                            else
  612.                            {
  613.                               if(eval("\x01") == 862)
  614.                               {
  615.                                  set("\x01",eval("\x01") - 152);
  616.                                  eval(┬º┬ºpop() or ┬º┬ºpop()).height.forward_back();
  617.                                  if(_loc1_["Math" + (_loc1_._y - 100)]._height != true)
  618.                                  {
  619.                                     delete _loc1_["Math" + (_loc1_._y - 100)].height;
  620.                                     _loc1_["Math" + (_loc1_._y - 100)]._xscale();
  621.                                  }
  622.                                  return Math.height;
  623.                               }
  624.                               if(eval("\x01") != 449)
  625.                               {
  626.                                  break;
  627.                               }
  628.                               set("\x01",eval("\x01") + 413);
  629.                               if(┬º┬ºpop())
  630.                               {
  631.                                  set("\x01",eval("\x01") - 152);
  632.                               }
  633.                            }
  634.                         }
  635.                      }
  636.                   }
  637.                }
  638.                set("\x01",eval("\x01") - 730);
  639.                nextFrame();
  640.                toggleHighQuality();
  641.                set(┬º┬ºpop(),┬º┬ºpop() >>> ┬º┬ºpop());
  642.                return ┬º┬ºpop()[┬º┬ºpop()]();
  643.             }
  644.             set("\x01",eval("\x01") + 262);
  645.             break;
  646.          }
  647.          if(eval("\x01") != 898)
  648.          {
  649.             if(eval("\x01") == 294)
  650.             {
  651.                set("\x01",eval("\x01") - 169);
  652.                Object.registerClass("soundClass",utils.FSound);
  653.             }
  654.             break;
  655.          }
  656.          set("\x01",eval("\x01") - 890);
  657.          ┬º┬ºpush(true);
  658.       }
  659.    }
  660. }
  661.